/********************************************************************************
  * @file     SD93F115B_rcc.c   						    	
  * @author   TEST TEAM 													    	
  * @version  v0															    	
  * @date     Septemper 2022												    	
  * @brief  
  *
  * Copyright (C) 2022  Hangzhou SDIC Microelectronics Co., Ltd
*********************************************************************************/

/* Includes */
    
#include "SD93F115B_rcc.h"

/*-----------------------------
 * 函数功能：RCC时钟重设为上电默认值
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
 void RCC_DeInit(void)
 {
	RCC->IHRC_CR=(uint32_t) 0x00010080;
	RCC->ILRC_CR=(uint32_t) 0x0001000F;
	RCC->XTOSC_CR=(uint32_t)0x00080103;
	RCC->MCLK_CFGR=(uint32_t) 0x00020001;
	RCC->CLKOUT_CR=(uint32_t) 0x00000000;
	RCC->AHB_ENR=(uint32_t) 0x00000003;
	RCC->APB_ENR=(uint32_t) 0x00000000;
	RCC->APB_CFGR1=(uint32_t) 0x00000000;
	RCC->APB_CFGR2=(uint32_t) 0x00000000;
 }
 /*-----------------------------
 * 函数功能：RCC时钟源的使能
 * 入口参数：RCC_CLKSource,NewState
 * 			 RCC_CLKSource: RCC_CLKSource_IHRC,RCC_CLKSource_ILRC,RCC_CLKSource_XTOSC1,RCC_CLKSource_XTOSC2
 *			 NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_CLKSourceCmd(uint32_t RCC_CLKSource,FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_RCC_CLKSource(RCC_CLKSource));	
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	
	if (NewState != DISABLE)
	{
		switch(RCC_CLKSource)
		{
			case RCC_CLKSource_IHRC: 
				 RCC->IHRC_CR |= IHRC_CR_IHRCEN;			
				 break;
			case RCC_CLKSource_ILRC:  
				 RCC->ILRC_CR |= RCC_CLKSource_ILRC;			
				 break;
			case RCC_CLKSource_XTOSC1: 
			     GPIO0->ADR|=0x03;  //使能 XTOSC1 之前，需要软件将 P00/P01 设置为模拟 IO
				 RCC->XTOSC_CR |= RCC_CLKSource_XTOSC1;
				 break;
#ifndef SD93F115B_JBS
#ifndef SD93F115B_IMR				 
			case RCC_CLKSource_XTOSC2:  
				 RCC->XTOSC_CR |= RCC_CLKSource_XTOSC2;
				 break;
#endif
#endif
			default:
				 break;
		}
	}
	else
	{
		switch(RCC_CLKSource)
		{
			case RCC_CLKSource_IHRC:  
				 RCC->IHRC_CR &= ~RCC_CLKSource_IHRC;			
				break;
			case RCC_CLKSource_ILRC:  
				 RCC->ILRC_CR &= ~RCC_CLKSource_ILRC;			
				break;
			case RCC_CLKSource_XTOSC1: 
				 RCC->XTOSC_CR &= ~RCC_CLKSource_XTOSC1;
				break;
#ifndef SD93F115B_JBS
#ifndef SD93F115B_IMR
			case RCC_CLKSource_XTOSC2:  
				 RCC->XTOSC_CR &= ~RCC_CLKSource_XTOSC2;
				break;
#endif
#endif
			default:
				break;
		}
	}		
}

/*-------------------------------------------
 * 函数功能：将系统时钟切换为过渡时钟IHRC/2
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *--------------------------------------------*/
void RCC_SetSYSCLKDefault(void)
{
	RCC->MCLK_CFGR |= MCLK_CFGR_SW;
}

/*-----------------------------
 * 函数功能：系统时钟的切换
 * 入口参数：RCC_SYSCLK,SYSCLKDIV
 *           RCC_SYSCLK: RCC_SYSCLK_IHRC,RCC_SYSCLK_ILRC,RCC_SYSCLK_XTOSC1,RCC_SYSCLK_XTOSC2_DIV2
 *           SYSCLKDIV: RCC_SYSCLK_DIV1,RCC_SYSCLK_DIV2,RCC_SYSCLK_DIV4,RCC_SYSCLK_DIV8
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_SYSCLKConfig(uint32_t RCC_SYSCLK,uint32_t SYSCLKDIV)
{
	/* Check the parameters */
	assert_param(IS_RCC_SYSCLK(RCC_SYSCLK));
	assert_param(IS_RCC_SYSCLKDIV(SYSCLKDIV));

	RCC->MCLK_CFGR |= MCLK_CFGR_SW;
		
	uint32_t tmpreg=0;
	tmpreg=(RCC->MCLK_CFGR&0x00030001)|RCC_SYSCLK|SYSCLKDIV;
	RCC->MCLK_CFGR = tmpreg;	
	RCC->MCLK_CFGR &= (~MCLK_CFGR_SW);

}

/*-----------------------------
 * 函数功能：AHB外设时钟使能
 * 入口参数：RCC_AHBPeriph,NewState
 *           RCC_AHBPeriph: RCC_AHBPeriph_FLITF,RCC_AHBPeriph_SRAM
 *			 NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_RCC_AHB_PERIPH(RCC_AHBPeriph));	
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	if (NewState != DISABLE)
	{
	
		RCC->AHB_ENR |= RCC_AHBPeriph;
	}
	else
	{
		RCC->AHB_ENR &= ~RCC_AHBPeriph;
	}		
}

/*-----------------------------
 * 函数功能：APB外设时钟使能
 * 入口参数：RCC_APBPeriph,NewState
 *  		 RCC_APBPeriph: APB可选操作外设有: RCC_APBPeriph_INT_KEY,RCC_APBPeriph_TM0,,RCC_APBPeriph_TM1RCC_APBPeriph_TM2\
 *           RCC_APBPeriph_RTC,RCC_APBPeriph_PWM0,RCC_APBPeriph_PWM1,RCC_APBPeriph_BUZ0,RCC_APBPeriph_BUZ1,RCC_APBPeriph_I2C\
 *           RCC_APBPeriph_SPI,RCC_APBPeriph_UART0,RCC_APBPeriph_UART1,RCC_APBPeriph_GPIO,RCC_APBPeriph_LCD,RCC_APBPeriph_SDADC\
 *           RCC_APBPeriph_SARADC,RCC_APBPeriph_PWR
 *			 NewState: NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
 void RCC_APBPeriphClockCmd(uint32_t RCC_APBPeriph, FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_RCC_APB_PERIPH(RCC_APBPeriph));
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	if (NewState != DISABLE)
	{
		/* Enable the PeriPheral by setting the Enable bit in the register */
		RCC->APB_ENR |= RCC_APBPeriph;
	}
	else
	{
		RCC->APB_ENR &= ~RCC_APBPeriph;	    
	}	
}	
/*-----------------------------
 * 函数功能：APB外设复位使能
 * 入口参数：RCC_APBPeriph,NewState
 *  		 RCC_APBPeriph: APB可选操作外设有: RCC_APBPeriph_INT_KEY,RCC_APBPeriph_TM0,,RCC_APBPeriph_TM1RCC_APBPeriph_TM2\
 *           RCC_APBPeriph_RTC,RCC_APBPeriph_PWM0,RCC_APBPeriph_PWM1,RCC_APBPeriph_BUZ0,RCC_APBPeriph_BUZ1,RCC_APBPeriph_I2C\
 *           RCC_APBPeriph_SPI,RCC_APBPeriph_UART0,RCC_APBPeriph_UART1,RCC_APBPeriph_GPIO,RCC_APBPeriph_LCD,RCC_APBPeriph_SDADC\
 *           RCC_APBPeriph_SARADC,RCC_APBPeriph_PWR
 *			 NewState: NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
void RCC_APBPeriphResetCmd(uint32_t RCC_APBPeriph, FunctionalState NewState)
{	
  /* Check the parameters */
  assert_param(IS_RCC_APB_RST_PERIPH(RCC_AHBPeriph));
  assert_param(IS_FUNCTIONAL_STATE(NewState));

  if (NewState != DISABLE)
  {
    RCC->APB_RSTR |= RCC_APBPeriph;
  }
  else
  {
    RCC->APB_RSTR &= ~RCC_APBPeriph;
  }								
}   
/*------------------------------------------------------------------------------------------------ 
 * 函数功能：外设时钟配置1
 * 入口参数：RCC_APBPeriph,RCC_TMCLK,RCC_TMCLK_DIV
 *			 RCC_APBPeriph: APB1外设时钟配置，可选操作外设有: RCC_APBPeriph_TM0,RCC_APBPeriph_TM1,RCC_APBPeriph_TM2
 *           RCC_TMCLK: 外设时钟源可选择 RCC_TMCLK_IHRC,RCC_TMCLK_ILRC,RCC_TMCLK_XTOSC1,RCC_TMCLK_XTOSC2,RCC_TMCLK_P23
 *			 RCC_TMCLK_DIV: 外设时钟源分频可选择 RCC_TMCLK_DIV1,RCC_TMCLK_DIV2,RCC_TMCLK_DIV4,RCC_TMCLK_DIV8,RCC_TMCLK_DIV16\
 *           RCC_TMCLK_DIV32,RCC_TMCLK_DIV64,RCC_TMCLK_DIV128
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-----------------------------------------------------------------------------------------------*/	
void RCC_APB1PeriphClockConfig(uint32_t RCC_APBPeriph,uint8_t RCC_TMCLK,uint8_t RCC_TMCLK_DIV)																					
{
	/* Check the parameters */
	assert_param(IS_RCC_APB_PERIPH(RCC_APBPeriph));		
	assert_param(IS_RCC_APB1_PERCLK(RCC_TMCLK));
	assert_param(IS_RCC_APB1_PERDIV(RCC_TMCLK_DIV));

	uint32_t tmpreg,tmpreg1=0;
	
    if(RCC_TMCLK==RCC_TMCLK_P23)
	{
		if(RCC_APBPeriph!=RCC_APBPeriph_TM0)
		{
			assert_param(IS_RCC_APB1_PERCLK(0x55));
			
			return ;
		}
			
	}	
	
	tmpreg1=RCC_TMCLK|RCC_TMCLK_DIV;
	
	switch(RCC_APBPeriph)
	{
		case RCC_APBPeriph_TM0:
			tmpreg=0xFFFFFF88 & RCC->APB_CFGR1;
			tmpreg |=tmpreg1;
			RCC->APB_CFGR1=tmpreg;
			break;
			
		case RCC_APBPeriph_TM1:  
			tmpreg=0xFFFFC8FF & RCC->APB_CFGR1;
			tmpreg |=(tmpreg1<<8);
			RCC->APB_CFGR1=tmpreg;		
			break;
			
		case RCC_APBPeriph_TM2: 
			tmpreg=0xFFCCFFFF&RCC->APB_CFGR1;
			tmpreg |=(tmpreg1<<16);
			RCC->APB_CFGR1=tmpreg;
			break;

		default:
			break;
	}	
}

/*-------------------------------------------------------------------------------------------------------
 * 函数功能：外设时钟配置2
 * 入口参数：RCC_APBPeriph,Periph2CLKSource,Periph2CLKDIV
 *			 RCC_APBPeriph: APB2外设时钟配置，可选操作外设有:RCC_APBPeriph_UART0,RCC_APBPeriph_UART1,RCC_APBPeriph_RTC,RCC_APBPeriph_BUZ0,RCC_APBPeriph_BUZ1\
 *  		 RCC_APBPeriph_I2C,RCC_APBPeriph_PWM0,RCC_APBPeriph_PWM1
 *			 Periph2CLKSource: APB2各外设可选择的时钟源如下 RCC_PWMCLK_IHRC,RCC_PWMCLK_ILRC,RCC_PWMCLK_XTOSC1,RCC_PWMCLK_XTOSC2\
 *           RCC_BUZCLK_ILRC,RCC_BUZCLK_IHRC_DIV750,RCC_RTCCLK_XTOSC1,RCC_RTCCLK_ILRC,RCC_RTCCLK_IHRC,RCC_UARTCLK_IHRC\
 *           RCC_UARTCLK_XTOSC2,RCC_UARTCLK_SYSCLK,RCC_I2CCLK_SYSCLK
 * 			 Periph2CLKDIV: APB2外设时钟预分频可选择为 RCC_PWMCLK_DIV1,RCC_PWMCLK_DIV2,RCC_PWMCLK_DIV4,RCC_PWMCLK_DIV8\
 *           RCC_I2CCLK_DIV2,RCC_I2CCLK_DIV4,RCC_I2CCLK_DIV8,RCC_I2CCLK_DIV16
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------------------------------------------------------------------------------*/
void RCC_APB2PeriphClockConfig(uint32_t RCC_APBPeriph,uint32_t Periph2CLKSource,uint32_t Periph2CLKDIV)											
{
	/* Check the parameters */	
	assert_param(IS_RCC_APB_PERIPH(RCC_APBPeriph));
	assert_param(IS_RCC_APB2_PERCLK(Periph2CLKSource));
	assert_param(IS_RCC_APB2_PERDIV(Periph2CLKDIV));

	uint32_t tmpreg,tmpreg1=0;	
	tmpreg1=Periph2CLKSource;
	
	switch(RCC_APBPeriph)
	{
		case RCC_APBPeriph_PWM0:
			tmpreg=0x033335F0&RCC->APB_CFGR2;
			tmpreg1=(tmpreg1|Periph2CLKDIV);
			break;
			
		case RCC_APBPeriph_PWM1:  
			tmpreg=0x0333350F&RCC->APB_CFGR2;
			tmpreg1=((tmpreg1|Periph2CLKDIV)<<4);		
			break;
			
		case RCC_APBPeriph_BUZ0: 
			tmpreg=0x033334FF&RCC->APB_CFGR2;
			break;
			
		case RCC_APBPeriph_BUZ1: 
			tmpreg=0x033305FF&RCC->APB_CFGR2;
			break;
			
		case RCC_APBPeriph_RTC: 
			tmpreg=0x033305FF&RCC->APB_CFGR2;
			break;

		case RCC_APBPeriph_I2C: 
			tmpreg=0x033035FF&RCC->APB_CFGR2;
			tmpreg1=Periph2CLKDIV;
			break;
			
		case RCC_APBPeriph_UART0: 
			tmpreg=0x030335FF&RCC->APB_CFGR2;
			break;
			
		case RCC_APBPeriph_UART1: 
			tmpreg=0x003335FF&RCC->APB_CFGR2;
			tmpreg1=(tmpreg1<<4);
			break;
			
		default:
			break;
	}
	tmpreg|=tmpreg1;
	RCC->APB_CFGR2=tmpreg;
}	  

 

/*-----------------------------
 * 函数功能：时钟输出
 * 入口参数：RCC_CLKOUT,NewState
 *			 RCC_CLKOUT: 时钟输出可选择 RCC_CLKOUT_SYSCLK,RCC_CLKOUT_IHRC,RCC_CLKOUT_ILRC,RCC_CLKOUT_XTOSC1\
 *           RCC_CLKOUT_XTOSC2_DIV2,RCC_CLKOUT_TMR0CLK,RCC_CLKOUT_TMR1CLK,RCC_CLKOUT_TMR2CLK
 *			 NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/	  
void RCC_ClockOut(uint8_t RCC_CLKOUT,FunctionalState NewState)										
{
	/* Check the parameters */	
	assert_param(IS_RCC_CLKOUT(RCC_CLKOUT));  
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	
    uint32_t tmpreg=0;

	tmpreg=(RCC->CLKOUT_CR&0x08)|RCC_CLKOUT;
	
	
	RCC->CLKOUT_CR =tmpreg;
	
	if (NewState == ENABLE)
		RCC->CLKOUT_CR|=CLKOUT_CR_CLKOUTEN;
	else
		RCC->CLKOUT_CR &= ~CLKOUT_CR_CLKOUTEN;		  	  
	
}

/*-----------------------------
 * 函数功能：晶振内部RF电阻使能(默认使能)
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_XTOSC_RESCmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	if (NewState != DISABLE)
	{
	
		RCC->XTOSC_CR |= XTOSC_RES_EN;
	}
	else
	{
		RCC->XTOSC_CR &= ~XTOSC_RES_EN;
	}		
}

/*-----------------------------
 * 函数功能：XTOSC1停振检测使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_XTOSC1CheckCmd(FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		RCC->XTOSC_CR|=XTOSC_CR_ST1EN;							
	}
	else 
	{
		RCC->XTOSC_CR &=~XTOSC_CR_ST1EN;		
	}
}
/*-----------------------------
 * 函数功能：读XTOSC1停振检测状态
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：XTOSC1停振检测状态bitstatus
 * 编写日期：
 * 作者    ：
 *------------------------------*/
FlagStatus RCC_GetXTOSC1CheckStatus(void)
{
	
	FlagStatus bitstatus = RESET;
  
	if((RCC->XTOSC_CR & XTOSC_CR_ST1RD)==RESET)
	{		
		bitstatus =	RESET;		
	}		
	else 
	{
		bitstatus = SET;		
	}
	return bitstatus;
}
/*-----------------------------
 * 函数功能：XTOSC1停振检测中断使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_XTOSC1ITCmd(FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		RCC->XTOSC_CR|=XTOSC_CR_XT1STPIE;							
	} 
	else 
	{
		RCC->XTOSC_CR &=~XTOSC_CR_XT1STPIE;		
	}
}
/*-----------------------------
 * 函数功能：读XTOSC1停振检测中断状态
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：XTOSC1停振检测中断状态bitstatus
 * 编写日期：
 * 作者    ：
 *------------------------------*/
ITStatus RCC_GetXTOSC1ITStatus(void)
{
  ITStatus bitstatus = RESET;
  
	if((RCC->XTOSC_SR & XTOSC_SR_XT1STPIF)==RESET)
	{		
		bitstatus=	RESET;		
	}		
	else 
	{
		bitstatus=SET;		
	}
	return bitstatus;	
}

/*-----------------------------
 * 函数功能：清除XTOSC1停振检测中断标志位
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
void RCC_ClearXTOSC1ITStatus(void)              
{
	RCC->XTOSC_SR=XTOSC_SR_XT1STPIF;
}

/*-----------------------------
 * 函数功能：设置XTOSC1驱动电流，数字越大，驱动电流越大
 * 入口参数：Idrive
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
void XTOSC1_SetDriveCurrent(uint8_t Idrive)
{
	/* Check the parameters */
    assert_param(IS_XTOSC1_Idrive(Idrive));	
	uint32_t tmpreg=0;
	tmpreg = RCC->XTOSC_CR;
	tmpreg &= 0xfffffff0;
	RCC->XTOSC_CR =(tmpreg|((Idrive&0x0f)<<0));
}

#ifndef SD93F115B_JBS
#ifndef SD93F115B_IMR
/*-----------------------------
 * 函数功能：XTOSC2停振检测使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_XTOSC2CheckCmd(FunctionalState NewState)	 
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		RCC->XTOSC_CR|=XTOSC_CR_ST2EN;							
	}
	else 
	{
		RCC->XTOSC_CR &=~XTOSC_CR_ST2EN;		
	}  
}  
  
/*-----------------------------
 * 函数功能：读XTOSC2停振检测状态
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：XTOSC2停振检测状态bitstatus
 * 编写日期：
 * 作者    ：
 *------------------------------*/
FlagStatus RCC_GetXTOSC2CheckStatus(void)  
{
  FlagStatus bitstatus = RESET;
  
	if((RCC->XTOSC_CR & XTOSC_CR_ST2RD)==RESET)
	{		
		bitstatus =	RESET;		
	}		
	else 
	{
		bitstatus = SET;		
	}
	return bitstatus;	
}  
   
 

/*-----------------------------
 * 函数功能：XTOSC2停振检测中断使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_XTOSC2ITCmd(FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		RCC->XTOSC_CR|=XTOSC_CR_XT2STPIE;							
	}
	else 
	{
		RCC->XTOSC_CR &=~XTOSC_CR_XT2STPIE;		
	}
}

/*-----------------------------
 * 函数功能：读XTOSC2停振检测中断状态
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：XTOSC2停振检测中断状态bitstatus
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
ITStatus RCC_GetXTOSC2ITStatus(void)  
{
  ITStatus bitstatus = RESET;
  
	if((RCC->XTOSC_SR & XTOSC_SR_XT2STPIF) ==RESET)
	{		
		bitstatus=	RESET;		
	}		
	else 
	{
		bitstatus=SET;		
	}
	return bitstatus;	
}

/*-----------------------------
 * 函数功能：清除XTOSC2停振检测中断标志位
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
void RCC_ClearXTOSC2ITStatus(void)               
{
	RCC->XTOSC_SR = XTOSC_SR_XT2STPIF;
} 

/*-----------------------------
 * 函数功能：设置XTOSC2驱动电流，数字越大，驱动电流越大
 * 入口参数：Idrive
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
void XTOSC2_SetDriveCurrent(uint8_t Idrive)
{
	/* Check the parameters */
    assert_param(IS_XTOSC2_Idrive(Idrive));	
	uint32_t tmpreg=0;
	tmpreg = RCC->XTOSC_CR;
	tmpreg &= 0xfff0ffff;
	RCC->XTOSC_CR =(tmpreg|((Idrive&0x0f)<<16));
}
#endif
#endif
/*-----------------------------
 * 函数功能：读状态寄存器复位标志状态
 * 入口参数：RCC_FLAG: 有如下复位状态标志位 RCC_FLAG_IHRCRDY,RCC_FLAG_HSWIF,RCC_FLAG_PORRST,RCC_FLAG_WWDGRST\
 *           RCC_FLAG_IWDGRST,RCC_FLAG_SFTRST,RCC_FLAG_PINRST,RCC_FLAG_LPWRRST,RCC_FLAG_OBLRST,RCC_FLAG_RSTERR
 * 出口参数：None
 * 返回值  ：复位标志状态bitstatus
 * 编写日期：
 * 作者    ：
 *------------------------------*/ 
RSTStatus RCC_GetResetFlagStatus(uint32_t RCC_FLAG)
{
	RSTStatus bitstatus = RESET;
	uint32_t statusreg = 0;
	/* Check the parameters */	
    assert_param(IS_RCC_FLAG(RCC_FLAG));
	
	if(RCC_FLAG==RCC_FLAG_IHRCRDY)
		statusreg =RCC->IHRC_CR & RCC_FLAG;
	
	if(RCC_FLAG==RCC_FLAG_HSWIF)
		statusreg =RCC->MCLK_CFGR & RCC_FLAG;
		
	if((RCC_FLAG!=RCC_FLAG_HSWIF)&&(RCC_FLAG!=RCC_FLAG_HSWIF))
		statusreg =RCC->RST_SR & RCC_FLAG;	
	
	if(statusreg ==RESET)
		bitstatus =	RESET;				
	else 
		bitstatus =SET;		
		
	return bitstatus;	
}

/*---------------------------------------
 * 函数功能：清除状态寄存器复位标志状态
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *---------------------------------------*/ 
void RCC_ClearResetFlagStatus(void )
{
	RCC->RST_SR |= RST_SR_RMVF;	
}
/*---------------------------------------------
 * 函数功能：清除发生硬件自动切换系统时钟标志
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *----------------------------------------------*/ 
void RCC_ClearHSWFlagStatus(void)
{
	RCC->MCLK_CFGR |= MCLK_CFGR_HSWIF;	
}

/*-----------------------------
 * 函数功能：载入IHRC校准值
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_LoadIHRCALValue(void)
{	
	uint32_t tmpreg=0;
	tmpreg=RCC->IHRC_CR&0xffff0000;
	tmpreg|=RCC->IHRC_CLBR;
	RCC->IHRC_CR=tmpreg;	
}
/*-----------------------------
 * 函数功能：手动调整IHRC校准值
 * 入口参数：IHRCALValue: 8位IHRC校准值，可设置位0x00~0xff
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_AdjustIHRCALValue(uint8_t IHRCALValue)
{
	uint32_t tmpreg=0;	
	tmpreg=RCC->IHRC_CR&0xffff8000;
	tmpreg|=IHRCALValue;
	RCC->IHRC_CR=tmpreg;
}

/*-----------------------------
 * 函数功能：载入ILRC校准值
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/	
void RCC_LoadILRCALValue(void)
{
	uint32_t tmpreg=0;
	
	tmpreg=RCC->ILRC_CR&0xffff0000;
	tmpreg|=RCC->ILRC_CLBR;
	
	RCC->ILRC_CR=tmpreg;		
}
/*-----------------------------
 * 函数功能：手动调整ILRC校准值
 * 入口参数：ILRCALValue: 8位ILRC校准值，可设置位0x00~0xff
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_AdjustILRCALValue(uint8_t ILRCALValue)
{
	uint32_t tmpreg=0;	
	tmpreg=RCC->ILRC_CR&0xffff0000;
	tmpreg|=ILRCALValue;
	RCC->ILRC_CR=tmpreg;
}

/*-----------------------------
 * 函数功能：使能IHRC CHOPPEREN
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void RCC_IHRCCHOPPERCmd(FunctionalState NewState)
{	
	
	if (NewState == ENABLE)
		RCC->IHRC_CR|=IHRC_CR_IHRC_CPEN;							
	else 
		RCC->IHRC_CR&=~IHRC_CR_IHRC_CPEN;		
}

/*****************************END OF FILE********************************/